import axios from 'axios'

// API配置
// 使用相对路径 '/api'，Vite会自动代理到本地后端
const API_BASE_URL = '/api'

// 创建axios实例
const apiClient = axios.create({
  baseURL: API_BASE_URL,
  timeout: 30000, // 30秒超时
  headers: {
    'Content-Type': 'application/json',
    'Accept': 'application/json'
  }
})

// 请求拦截器
apiClient.interceptors.request.use(
  (config) => {
    console.log('API请求:', config.method.toUpperCase(), config.url, config.data)
    return config
  },
  (error) => {
    console.error('请求拦截器错误:', error)
    return Promise.reject(error)
  }
)

// 响应拦截器
apiClient.interceptors.response.use(
  (response) => {
    console.log('API响应:', response.status, response.data)
    return response
  },
  (error) => {
    console.error('API响应错误:', error.response?.status, error.response?.data)
    
    let errorMessage = '网络请求失败'
    
    if (error.response) {
      // 服务器响应错误
      switch (error.response.status) {
        case 400:
          errorMessage = '请求参数错误'
          break
        case 404:
          errorMessage = '请求的资源不存在'
          break
        case 500:
          errorMessage = '服务器内部错误'
          break
        default:
          errorMessage = `服务器错误 (${error.response.status})`
      }
    } else if (error.request) {
      // 请求已发送但没有收到响应
      errorMessage = '无法连接到服务器，请检查网络连接'
    } else {
      // 其他错误
      errorMessage = error.message || '未知错误'
    }
    
    return Promise.reject(new Error(errorMessage))
  }
)

// 聊天API
export const chatAPI = {
  /**
   * 发送问题到后端API
   * @param {string} question - 用户问题
   * @param {number} limit - 返回结果数量限制
   * @returns {Promise} 返回回答和参考资料
   */
  async sendQuestion(question, limit = 20) {
    try {
      // 构建请求数据
      const requestData = {
        question: question,
        limit: limit
      }

      // 发送POST请求到后端
      const response = await apiClient.post('/qa', requestData)
      
      // 处理响应数据
      const result = response.data
      
      // 确保返回数据格式正确
      return {
        question: result.question || question,
        answer: result.answer || '抱歉，无法获取回答。',
        qa_results: result.qa_results || [],
        table_images: result.table_images || {},
        success: true
      }
      
    } catch (error) {
      console.error('发送问题失败:', error)
      
      // 返回错误信息
      return {
        question: question,
        answer: `抱歉，处理您的问题时出现错误：${error.message}`,
        qa_results: [],
        success: false,
        error: error.message
      }
    }
  },

  /**
   * 检查后端连接状态
   * @returns {Promise<boolean>} 返回连接状态
   */
  async checkConnection() {
    try {
      const response = await apiClient.get('/health')
      return response.data.status === 'ok'
    } catch (error) {
      console.warn('后端连接检查失败:', error)
      return false
    }
  },

  /**
   * 获取系统状态
   * @returns {Promise<object>} 返回系统状态信息
   */
  async getSystemStatus() {
    try {
      const response = await apiClient.get('/status')
      return response.data
    } catch (error) {
      console.error('获取系统状态失败:', error)
      return {
        status: 'error',
        message: error.message
      }
    }
  },

  /**
   * 获取示例问题列表
   * @returns {Promise<Array>} 返回示例问题数组
   */
  async getSampleQuestions() {
    try {
      const response = await apiClient.get('/sample-questions')
      return response.data.questions || []
    } catch (error) {
      console.warn('获取示例问题失败:', error)
      // 返回默认示例问题
      return [
        '大伙房水库的调度规则是什么？',
        '大伙房水库自然地理图',
        '大伙房水库超标准洪水的调度方式是什么？'
      ]
    }
  },

  /**
   * 以SSE流式发送问题并接收答案
   * @param {string} question - 用户问题
   * @param {object} opts - 回调集合 { onRefs, onDelta, onDone, onError }
   */
  async sendQuestionStream(question, opts = {}) {
    const { onRefs, onDelta, onDone, onError } = opts
    try {
      const response = await fetch(`${API_BASE_URL}/qa/stream`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Accept': 'text/event-stream'
        },
        body: JSON.stringify({ question, limit: 20 })
      })

      if (!response.ok) {
        throw new Error(`服务器返回错误: ${response.status}`)
      }

      const reader = response.body.getReader()
      const decoder = new TextDecoder('utf-8')
      let buffer = ''

      while (true) {
        const { value, done } = await reader.read()
        if (done) break
        buffer += decoder.decode(value, { stream: true })

        // 解析SSE消息：以两个换行分隔
        const parts = buffer.split('\n\n')
        buffer = parts.pop() || ''
        for (const part of parts) {
          // 每个事件由若干行组成：event: xxx\ndata: yyy
          const lines = part.split('\n')
          let event = 'delta'
          let data = ''
          for (const line of lines) {
            if (line.startsWith('event:')) {
              event = line.slice(6).trim()
            } else if (line.startsWith('data:')) {
              data += line.slice(5).trim()
            }
          }

          try {
            const payload = data ? JSON.parse(data) : {}
            if (event === 'refs' && typeof onRefs === 'function') {
              onRefs(payload.qa_results || [])
            } else if (event === 'delta' && typeof onDelta === 'function') {
              onDelta(payload.delta || '')
            } else if (event === 'done' && typeof onDone === 'function') {
              onDone(payload)
            } else if (event === 'error' && typeof onError === 'function') {
              onError(payload.error || '未知错误')
            }
          } catch (e) {
            console.warn('解析SSE事件失败:', e, part)
          }
        }
      }
    } catch (error) {
      console.error('流式发送问题失败:', error)
      if (typeof onError === 'function') onError(error.message)
    }
  },

  /**
   * 使用原生EventSource进行SSE流式（推荐）
   * @param {string} question - 用户问题
   * @param {object} opts - 回调集合 { onRefs, onDelta, onDone, onError }
   */
  async sendQuestionStreamES(question, opts = {}) {
    const { onRefs, onDelta, onDone, onError } = opts
    if (typeof EventSource === 'undefined') {
      throw new Error('当前环境不支持EventSource')
    }

    const url = `${API_BASE_URL}/qa/stream_get?question=${encodeURIComponent(question)}&limit=20`
    const es = new EventSource(url, { withCredentials: false })

    es.addEventListener('refs', (e) => {
      try {
        const payload = JSON.parse(e.data || '{}')
        if (typeof onRefs === 'function') onRefs(payload.qa_results || [])
      } catch (err) {
        console.warn('解析refs失败:', err)
      }
    })

    es.addEventListener('delta', (e) => {
      try {
        const payload = JSON.parse(e.data || '{}')
        if (typeof onDelta === 'function') onDelta(payload.delta || '')
      } catch (err) {
        console.warn('解析delta失败:', err)
      }
    })

    es.addEventListener('done', (e) => {
      try {
        const payload = JSON.parse(e.data || '{}')
        if (typeof onDone === 'function') onDone(payload)
      } catch {}
      es.close()
    })

    es.addEventListener('error', (e) => {
      if (typeof onError === 'function') onError('SSE连接错误')
      try { es.close() } catch {}
    })
  }
}

export default chatAPI